/**
 * API配置工具
 * 用于动态检测和配置API基础URL，解决网络环境访问问题
 */

interface ApiConfig {
  baseUrl: string;
  nodeApiUrl: string;
  websocketUrl?: string;
}

class ApiConfigManager {
  private static instance: ApiConfigManager;
  private config: ApiConfig | null = null;
  private detectionPromise: Promise<ApiConfig> | null = null;

  static getInstance(): ApiConfigManager {
    if (!ApiConfigManager.instance) {
      ApiConfigManager.instance = new ApiConfigManager();
    }
    return ApiConfigManager.instance;
  }

  /**
   * 获取当前访问的主机信息
   */
  private getCurrentHost(): { hostname: string; port: string; protocol: string } {
    const { hostname, port, protocol } = window.location;
    return { hostname, port, protocol };
  }

  /**
   * 动态检测可用的API地址
   */
  private async detectApiUrls(): Promise<ApiConfig> {
    const { hostname, protocol } = this.getCurrentHost();
    
    // 基于当前访问方式构建可能的API地址
    const candidates = [
      // 1. 环境变量中的配置（优先级最高）
      import.meta.env.VITE_API_BASE_URL,
      import.meta.env.VITE_NODE_API_BASE_URL,
      
      // 2. 如果是网络访问，尝试同一主机的8000端口
      hostname !== 'localhost' && hostname !== '127.0.0.1' 
        ? `${protocol}//${hostname}:8000`
        : null,
        
      // 3. 如果是localhost访问，使用127.0.0.1
      hostname === 'localhost' || hostname === '127.0.0.1'
        ? 'http://127.0.0.1:8000'
        : null,
        
      // 4. 最后的回退选项
      'http://127.0.0.1:8000'
    ].filter(Boolean) as string[];

    // console.log('🔍 API地址检测候选列表:', {
    //   currentHost: `${protocol}//${hostname}`,
    //   candidates
    // });

    // 快速检测每个候选地址
    for (const candidate of candidates) {
      try {
        // console.log(`🔍 检测API地址: ${candidate}`);
        
        // 尝试访问健康检查端点或简单的选项请求
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), 2000); // 2秒超时
        
        const response = await fetch(`${candidate}/health`, {
          method: 'GET',
          signal: controller.signal,
          mode: 'cors'
        }).catch(() => {
          // 如果健康检查失败，尝试OPTIONS请求
          return fetch(candidate, {
            method: 'OPTIONS',
            signal: controller.signal,
            mode: 'cors'
          });
        });
        
        clearTimeout(timeoutId);
        
        if (response.ok || response.status === 404) {
          // 404也认为是可访问的（只是没有对应端点）
          // console.log(`✅ API地址可用: ${candidate}`);
          return {
            baseUrl: candidate,
            nodeApiUrl: candidate
          };
        }
      } catch (error) {
        console.warn(`❌ API地址不可用: ${candidate}`, error);
        continue;
      }
    }

    // 如果所有检测都失败，使用默认配置但添加警告
    console.warn('⚠️ 所有API地址检测失败，使用默认配置');
    const defaultUrl = candidates[candidates.length - 1];
    return {
      baseUrl: defaultUrl,
      nodeApiUrl: defaultUrl
    };
  }

  /**
   * 获取API配置（缓存结果，避免重复检测）
   */
  async getApiConfig(): Promise<ApiConfig> {
    // 如果已有配置，直接返回
    if (this.config) {
      return this.config;
    }

    // 如果正在检测，等待检测完成
    if (this.detectionPromise) {
      return await this.detectionPromise;
    }

    // 开始新的检测
    this.detectionPromise = this.detectApiUrls();
    this.config = await this.detectionPromise;
    
    // console.log('🎯 最终API配置:', this.config);
    return this.config;
  }

  /**
   * 获取基础API URL
   */
  async getBaseUrl(): Promise<string> {
    const config = await this.getApiConfig();
    return config.baseUrl;
  }

  /**
   * 获取Node API URL
   */
  async getNodeApiUrl(): Promise<string> {
    const config = await this.getApiConfig();
    return config.nodeApiUrl;
  }

  /**
   * 重置配置（用于强制重新检测）
   */
  reset(): void {
    this.config = null;
    this.detectionPromise = null;
  }

  /**
   * 手动设置API配置（用于调试或特殊情况）
   */
  setConfig(config: ApiConfig): void {
    this.config = config;
    // console.log('🔧 手动设置API配置:', config);
  }
}

// 导出单例实例
export const apiConfigManager = ApiConfigManager.getInstance();

// 便捷方法
export async function getApiBaseUrl(): Promise<string> {
  return await apiConfigManager.getBaseUrl();
}

export async function getNodeApiUrl(): Promise<string> {
  return await apiConfigManager.getNodeApiUrl();
}

/**
 * 同步获取API地址的回退方法
 * 仅在异步方法不可用时使用
 */
export function getApiBaseUrlSync(): string {
  const { hostname, protocol } = window.location;
  
  // 检查是否为Edge浏览器
  const isEdge = /Edge\//.test(navigator.userAgent) || /Edg\//.test(navigator.userAgent);
  
  // 如果有环境变量，优先使用
  if (import.meta.env.VITE_API_BASE_URL) {
    return import.meta.env.VITE_API_BASE_URL;
  }
  
  // Edge浏览器在网络环境下的特殊处理
  if (isEdge && (window as any).EDGE_API_CONFIG) {
    // console.log('🔧 使用Edge专用API配置');
    return (window as any).EDGE_API_CONFIG.apiBase;
  }
  
  // 根据当前访问方式决定
  if (hostname !== 'localhost' && hostname !== '127.0.0.1') {
    return `${protocol}//${hostname}:8000`;
  }
  
  return 'http://127.0.0.1:8000';
}

export function getNodeApiUrlSync(): string {
  const { hostname, protocol } = window.location;
  
  // 检查是否为Edge浏览器
  const isEdge = /Edge\//.test(navigator.userAgent) || /Edg\//.test(navigator.userAgent);
  
  // 如果有环境变量，优先使用
  if (import.meta.env.VITE_NODE_API_BASE_URL) {
    return import.meta.env.VITE_NODE_API_BASE_URL;
  }
  
  // Edge浏览器在网络环境下的特殊处理
  if (isEdge && (window as any).EDGE_API_CONFIG) {
    // console.log('🔧 使用Edge专用Node API配置');
    return (window as any).EDGE_API_CONFIG.apiBase;
  }
  
  // 根据当前访问方式决定
  if (hostname !== 'localhost' && hostname !== '127.0.0.1') {
    return `${protocol}//${hostname}:8000`;
  }
  
  return 'http://127.0.0.1:8000';
}

// 调试工具（开发环境）
if (import.meta.env.DEV) {
  (window as any).apiConfigDebug = {
    getConfig: () => apiConfigManager.getApiConfig(),
    reset: () => apiConfigManager.reset(),
    setConfig: (config: ApiConfig) => apiConfigManager.setConfig(config),
    getCurrentHost: () => {
      const { hostname, port, protocol } = window.location;
      return { hostname, port, protocol };
    }
  };
} 